/**
 * 多领域管理
 *
 * 1111 1111
 *  05   05 99     00 02
 */
import Rd from "../../1110111011101110/qbasics/basics/Rd";


export default class Rg{
    constructor(root) {
        this.hard=new Rd();
        this.root=root;
        // 领域管理
        this.rds= {};
        // 资源映射
        //资源管理
        this.ids=new Rd();
        let s = this.rds.next_id();

        this.rds.add(s,this.ids)
        // Rd 不直接保存文件

        //多个领域    多new rd

        // 需要做一下映射     映射Dx  1w个比特
        // 领域 3   第5个dx  保存在 6这个文件的2dx
        //本身领域也需要保存  领域3  文字映射 文件管理
        // dx rx 安装文件大小操作数据
        // rd block row 结构化数据
        this.root=null;
    }


    /**
     * 添加领域
     */
    addArea( id,str){

        let _id = this.ids.next_id();
        this.ids.saveRow(id,str)
        this.rds.add(_id,new Rd())
        return _id;
    }


    /**
     * 查找领域id
     * @param str
     * @returns {*}
     */
    findAreaId(str){

       let _id= this.ids.find(str);
       return _id;

    }

    loadData(){

        let buff= this.root.load(0)

        let dx = new Dx();
        dx.loadData(buff);

        // 加载数据
        let rxListElement = dx.rxList[0];

        this.hard=new Rd();
        this.hard.loadData(rxListElement.outData())


        // 加载目录
         let contRow= this.hard.find(0)


        let contRxs=  this.load(contRow.find(2),contRow.find(3),contRow.find(4))
       let resRd=   loudRd(contRxs)

        // 读取  ids; id 加载目录
        let idsRow= this.hard.find(1)

        let idsRd=   loudRd(idsRow.find(2),idsRow.find(3),idsRow.find(4))

        this.idsRd= idsRd;

        //遍历目录 加载所有的领域
        resRd.list.forEach(row =>{

            let rd=loudRd(row.find(2),row.find(3),rowfind(4))
            this.rds[row.find(1)]=rd;
        })
    }

    /**
     * 退出保存全部数据
     */
    outData(){
        let _cont=new Rd();
        this.ids.forEach(row =>{

                let _rd= this.rds[row.find(1)];
                let outDataBuff = _rd.outData();
                let _rxs= Rx.buffToRxs(outDataBuff)
                let _row=save(row.find(1) ,_rxs)
            _cont.save(_row)
            }
        )
       let _idsBUff= this.ids.outData();
        let _idsRxs= Rx.buffToRxs(_idsBUff)
        let _idsRow=save(1,_idsRxs)

        let _contBUff= this._cont.outData();
        let _contRxs= Rx.buffToRxs(_contBUff)
        let _contRow=save(0,_contRxs)


        let hredRd = new Rd();
        hredRd.addRow(_contRow)
        hredRd.addRow(_idsRow)
        let hredBuff = hredRd.outData();
        let hredRxs = Rx.buffToRxs(hredBuff);

         save(0,hredRxs)

    }

    /**
     *  根据目录起 加载
     * @param a
     * @param b
     * @param c
     * @returns {*}
     */
    loudRd(contRx){

        let contBuff=   contRx.outData();

        let contRd=new Rd();
        contRd.loadData(contBuff);

        return resRd;
    }




    /**
     * 保存 数据
     * @param id
     * @param rxs
     * @returns {*}
     */
    save(id,rxs){
        let reRow=new Row();



        let _num=rxs.length+1;

        let _no=this.no;
        let _startId=this.startId;


        let _endId=  _num % 10000;

        let __no= _num /10000;

        let _endNo=_no+__no;



        if(__no >0){

            let _endNum= 10000-_startId;
            let _rxs= rex.slice(0,_endNum)
            let _rxBuff=Rx.rxsToBuff(_rxs)
             this.root.save(no,_startId,_endNum,_rxBuff)

            for (var i=0;i<__no;i++){
                _no=_no+1;

                if(i<__no){

                    let _rxs= rex.slice(_endNum,10000)
                    let _rxBuff=Rx.rxsToBuff(_rxs)
                    this.root.save(_no,0,10000,_rxBuff)
                    _endNum=_endNum+1000;
                }else {
                    let _rxs= rex.slice(_endNum,_num)
                    let _rxBuff=Rx.rxsToBuff(_rxs)
                    this.root.save(_no,0,_endId,_rxBuff)
                }
            }


        }else {

            let buff=Rx.rxsToBuff(rxs)

            this.root.save(no,_startId,_endNo,buff)

        }


        this.no=_endNo;
        this.startId=_endId;

        reRow=new Row(id,_no,_startId,_num);

        return reRow;
    }



    /**
     *  读取数据 数据id ,开始位置, 数量
     * @param no
     * @param startId
     * @param num
     */
    load(no,startId,num){

        this.root.load(no)

        let _num=startId+num;

        let _endId=  _num % 10000;

        let _no= _num /10000;

        let _endNo=no+_no;

        let rxs= new Array();
        if(_no >0){

            let buff=this.root.load(no)
            let dx=new Dx();
            dx.loadData(buff)
            let _rxs= dx.rxList.slice(startId )
            rxs.push(..._rxs)

            for (var i=0;i<_no;i++){
                let buff=this.root.load(no+i)
                let dx=new Dx();
                dx.loadData(buff)
                if(i<_no){

                    let _rxs= dx.rxList.slice(startId)
                    rxs.push(..._rxs)
                }else {
                    let _rxs= dx.rxList.slice(startId,_endNo)
                    rxs.push(..._rxs)
                }
            }


        }else {

            let buff=this.root.load(no)
            let dx=new Dx();
            dx.loadData(buff)
            let _rxs= dx.rxList.slice(startId,_endId)
            rxs.push(..._rxs)
        }


        return rxs;



    }



    /**
     * 启动
     * @param buff
     * @param rdConf
     */
    start(){

        let buff= this.root.load(0)



        let dx = new Dx();
        dx.loadData(buff);



    }

    /**
     * 保存
     */
    save(){

    }

    /**
     * 初始化
     */
    init(){

    }

    confRoot(root){
        this.root=root;
    }
    /**
     * 加载数据
     * @param no
     * @returns {*}
     */
    async loadData(no){
        await   this.root.saveData(no,buff);
    }


    /**
     * 保存数据
     * @param buff
     */
    async saveData(buff){
        await  this.root.saveData(no,buff);
    }




}
